home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource5 / 357_01 / cstar1.exe / STR.C < prev    next >
C/C++ Source or Header  |  1991-06-18  |  5KB  |  281 lines
  1. /*
  2.     C* -- string handling routines.
  3.  
  4.     source: str.c
  5.     started: October 6, 1985
  6.     version:
  7.         December 6, 1986
  8.         March 7, 1989
  9.  
  10.     PUBLIC DOMAIN SOFTWARE
  11.  
  12.     The CSTAR program was placed in    the public domain on June 15, 1991,
  13.     by its author and sole owner,
  14.  
  15.         Edward K. Ream
  16.         1617 Monroe Street
  17.         Madison, WI 53711
  18.         (608) 257-0802
  19.  
  20.     CSTAR may be used for any commercial or non-commercial purpose.
  21.  
  22.     See cstar.h or cstar.c for a DISCLAIMER OF WARRANTIES.
  23. */
  24. #include "cstar.h"
  25.  
  26. /*
  27.     All routines in this file are externally visible:
  28. */
  29. void    str_cat        (register char *s1, register char *s2);
  30. int    str_cmp        (register char *s1, register char *s2);
  31. void    str_cpy        (register char *s1, register char *s2);
  32. bool    str_eq        (register char *s1, register char *s2);
  33. char *    str_galloc    (register char *s);
  34. char *    str_gcat    (register char *s1, register char *s2);
  35. char *    str_lalloc    (register char *s);
  36. char *    str_lcat    (register char *s1, register char *s2);
  37. int    str_len        (register char *s);
  38. char *    str_name    (void);
  39. char *    str_salloc    (register char *s);
  40. char *    chr_salloc    (register char *s, int n);
  41.  
  42. /*
  43.     Concatenate s2 to the end of s1.
  44. */
  45. void
  46. str_cat(register char *s1, register char *s2)
  47. {
  48.     TRACEP("str_cat", printf("(%s, %s)\n", s1, s2));
  49.  
  50.     while(*s1) {
  51.         s1++;
  52.     }
  53.     do {
  54.         *s1++ = *s2;
  55.     }
  56.     while (*s2++);
  57.  
  58.     return;
  59. }
  60.  
  61. /*
  62.     Compare s1 and s2.
  63.     Return <0  ==0  >0
  64. */
  65. bool
  66. str_cmp(register char *s1, register char *s2)
  67. {
  68.     register char c;
  69.  
  70.     TRACEPB("str_cmp", printf("(%s, %s)\n", s1, s2));
  71.  
  72.     while (*s1 == *s2) {
  73.         if (*s1 == '\0') {
  74.             RETURN_BOOL("str_cmp", 0);
  75.         }
  76.         else {
  77.             s1++;
  78.             s2++;
  79.         }
  80.     }
  81.     RETURN_BOOL("str_cmp", ((int)*s1) - ((int)*s2));
  82. }
  83.  
  84. /*
  85.     Copy s2 to s1.
  86.     s1 must be large enough to hold s2.
  87. */
  88. void
  89. str_cpy(register char *s1, register char *s2)
  90. {
  91.     TRACEP("str_cpy", printf("(%p, %s)\n", s1, s2));
  92.  
  93.     while (*s2) {
  94.         *s1++ = *s2++;
  95.     }
  96. }
  97.  
  98. /*
  99.     Return TRUE if s1 == s2
  100. */
  101. bool
  102. str_eq(register char *s1, register char *s2)
  103. {
  104.     TRACEPB("str_eq", printf("(%s, %s)\n", s1, s2));
  105.  
  106.     while(*s1) {
  107.         if (*s1++ != *s2++) {
  108.             RETURN_BOOL("str_eq", FALSE);
  109.         }
  110.     }
  111.     RETURN_BOOL("str_eq", !*s2);
  112. }
  113.  
  114. /*
  115.     Allocate global (static) memory big enough to hold the string,
  116.     then copy the string to the allocated memory.
  117.     NOTE: if scope is set up properly, this is not really required
  118.     as a separate routine.
  119. */
  120. char *
  121. str_galloc(register char *s)
  122. {
  123.     register char * p;
  124.     register int n;
  125.  
  126.     TRACEPB("str_galloc", printf("(%s)\n", s));
  127.  
  128.     n = str_len(s);
  129.     p = mg_alloc(n + 1);
  130.     str_cpy(p, s);
  131.  
  132.     RETURN_STRING("str_galloc", p);
  133. }
  134.  
  135. /*
  136.     Allocate global memory for two strings
  137. */
  138. char *
  139. str_gcat(register char *s1, register char *s2)
  140. {
  141.     register char * p;
  142.     register int n1, n2;
  143.  
  144.     TRACEPB("str_gcat", printf("(%s, %s)\n", s1, s2));
  145.  
  146.     n1 = str_len(s1);
  147.     n2 = str_len(s2);
  148.     p = mg_alloc(n1 + n2 + 1);
  149.     str_cpy(p, s1);
  150.     str_cpy(p + n1, s2);
  151.  
  152.     RETURN_STRING("str_gcat", p);
  153. }
  154.  
  155. /*
  156.     Same as str_galloc() except local scope.
  157. */
  158. char *
  159. str_lalloc(register char *s)
  160. {
  161.     register char * p;
  162.     register int n;
  163.  
  164.     TRACEPB("str_lalloc", printf("(%s)\n", s));
  165.  
  166.     n = str_len(s);
  167.     p = ml_alloc(n + 1);
  168.     str_cpy(p, s);
  169.  
  170.     RETURN_STRING("str_lalloc", p);
  171. }
  172.  
  173. /*
  174.     Allocate local memory for two strings
  175. */
  176. char *
  177. str_lcat(register char *s1, register char *s2)
  178. {
  179.     register char * p;
  180.     register int n1, n2;
  181.  
  182.     TRACEPB("str_lcat", printf("(%s, %s)\n", s1, s2));
  183.  
  184.     n1 = str_len(s1);
  185.     n2 = str_len(s2);
  186.     p = ml_alloc(n1 + n2 + 1);
  187.     str_cpy(p, s1);
  188.     str_cpy(p + n1, s2);
  189.  
  190.     RETURN_STRING("str_lcat", p);
  191. }
  192.  
  193. /*
  194.     Return the length of a string.
  195. */
  196. int
  197. str_len(register char *s)
  198. {
  199.     register int len;
  200.  
  201.     TRACEPB("str_len", printf("(%s)\n", s));
  202.  
  203.     len=0;
  204.     while (*s++) {
  205.         len++;
  206.     }
  207.  
  208.     RETURN_INT("str_len", len);
  209. }
  210.  
  211. /*
  212.     Return a unique symbolic name for a string.
  213. */
  214. char *
  215. str_name(void)
  216. {
  217.     static char buf[LONG_DIGITS+5];
  218.     static unsigned long ssn = 1;
  219.  
  220.     TICKB("str_name");
  221.  
  222.     buf[0] = 'S';
  223.     conul2sc(ssn, buf+1, 3);
  224.  
  225.     ssn++;
  226.     RETURN_STRING("str_name", &buf[0]);
  227. }
  228.  
  229. /*
  230.     Same as str_galloc() but for appropriate scope.
  231. */
  232. char *
  233. str_salloc(register char *s)
  234. {
  235.     register char * p;
  236.     register int n;
  237.  
  238.     TRACEPB("str_salloc", printf("(%s)\n", s));
  239.  
  240.     n = str_len(s);
  241.  
  242.     switch(scope.s_scope) {
  243.     case PROTO_SCOPE:
  244.     case BLOCK_SCOPE:
  245.     case FNDEF_SCOPE:
  246.         p = ml_alloc(n + 1);
  247.         break;
  248.     case FILE_SCOPE:
  249.     default:
  250.         p = mg_alloc(n + 1);
  251.     }
  252.     str_cpy(p, s);
  253.  
  254.     RETURN_STRING("str_salloc", p);
  255. }
  256.  
  257. char *
  258. chr_salloc(register char *s, int n)
  259. {
  260.     register char *p, *d;
  261.  
  262.     TRACEPB("chr_salloc", printf("(%s, %d)\n", s, n));
  263.  
  264.     switch(scope.s_scope) {
  265.     case PROTO_SCOPE:
  266.     case BLOCK_SCOPE:
  267.     case FNDEF_SCOPE:
  268.         d = p = ml_alloc(n + 1);
  269.         break;
  270.  
  271.     case FILE_SCOPE:
  272.     default:
  273.         d = p = mg_alloc(n + 1);
  274.     }
  275.     while (n--) {
  276.         *p++ = *s++;
  277.     }
  278.  
  279.     RETURN_STRING("chr_salloc", d);
  280. }
  281.